package com.example.searchservice.service.impl;

import com.hankcs.hanlp.HanLP;
import com.hankcs.hanlp.seg.common.Term;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class HanLPServiceImpl {

    /**
     * 中华人民共和国的一个公司里的一个小牛马云爹
     *
     * 词语	词性	说明
     * 中华人民共和国	ns	地名
     * 的	uj	助词"的"
     * 一个	mq	数量词
     * 公司	n	名词
     * 里	f	方位词
     * 小	a	形容词
     * 牛马	n	名词
     * 云	n	名词
     * 爹	n	名词
     * @param text
     * @return
     */
    public List<Term> segment(String text) {
        return calculateOffsets(HanLP.segment(text),text);
    }
    // 可以继续封装其他功能，如关键词提取、命名实体识别等
    public List<String> extractKeyword(String content, int amount) {
        return HanLP.extractKeyword(content, amount);
    }

    /**
     * 计算每个词在原文中的正确偏移量
     */
    private List<Term> calculateOffsets(List<Term> terms, String text) {
        List<Term> result = new ArrayList<>();
        int currentPosition = 0;

        for (Term term : terms) {
            String word = term.word;
            int wordLength = word.length();

            // 在文本中从当前位置开始查找这个词
            int foundIndex = findWordInText(text, word, currentPosition);

            if (foundIndex != -1) {
                // 找到匹配，创建DTO并设置正确的偏移量
                Term dto = new Term(word, term.nature);
                dto.offset = foundIndex;
                result.add(dto);
                // 更新当前位置到这个词的结尾
                currentPosition = foundIndex + wordLength;
            } else {
                // 如果找不到（理论上不应该发生），使用当前位置作为偏移量
                Term dto = new Term(word, term.nature);
                dto.offset = currentPosition;
                result.add(dto);
                currentPosition += wordLength;
            }
        }

        return result;
    }

    /**
     * 在文本中查找词语的精确位置
     */
    private int findWordInText(String text, String word, int startFrom) {
        if (startFrom >= text.length()) {
            return -1;
        }

        // 首先尝试精确匹配从startFrom开始的位置
        if (startFrom + word.length() <= text.length()) {
            String substring = text.substring(startFrom, startFrom + word.length());
            if (substring.equals(word)) {
                return startFrom;
            }
        }

        // 如果当前位置不匹配，在整个文本中搜索（从startFrom开始）
        for (int i = startFrom; i <= text.length() - word.length(); i++) {
            String substring = text.substring(i, i + word.length());
            if (substring.equals(word)) {
                return i;
            }
        }

        return -1;
    }
}